import { validateCardType } from '@/utils/cardUtils';
// 花色优先级（方块 > 红桃 > 梅花 > 黑桃）
export const suitPriority = {
    '♦': 4,  // 方块
    '♥': 3,  // 红桃
    '♣': 2,  // 梅花
    '♠': 1   // 黑桃
  };
  
  // 特殊牌权重（小王 < 大王）
 export const specialWeights = {
    'joker': 200,  // 小王（黑色）
    'Joker': 300   // 大王（红色）
  };
  
  // 点数权重（从大到小）
  export const pointWeights = {
    '2': 15,
    'A': 14,
    'K': 13,
    'Q': 12,
    'J': 11,
    '10': 10,
    '9': 9,
    '8': 8,
    '7': 7,
    '6': 6,
    '5': 5,
    '4': 4,
    '3': 3
  };

// 斗地主完整牌型判断及比较逻辑
 export function canBeat(selectedCards, upCards) {
    // 获取双方牌型信息
    console.log(selectedCards)
    console.log(upCards)
    const selectedInfo = validateCardType(selectedCards);
    const upInfo = validateCardType(upCards);
    console.log(selectedInfo)
    console.log(upInfo)
    // 类型优先级比较（数字越大优先级越高）
    const typePriority = { 
      'single': 1,    // 单张
      'pair': 2,      // 对子
      'triple': 3,      // 三张
      "threeWithSingle":9,
      "threeWithPair":10,
      'straight': 4,  // 顺子
      'doubleStraight': 5,// 连对
      'airplane': 6,  // 飞机
      'bomb': 7,      // 炸弹
      'rocket': 8     // 火箭
    };
    if(selectedInfo=='rocket'){
      console.log("王炸");
      return true
    }
  if(selectedCards=="bomb"){
    if(upInfo!="bomb"&&upInfo!="rocket"){
      console.log("炸弹")
      return true;
    }
  }

    // 类型不同时比较优先级
    if (selectedInfo !== upInfo) {
      console.log("牌不同")
      return false;
    }
  
    // 同类型牌型比较
    switch(selectedInfo) {
      case 'single':console.log("单子")
      console.log(getMaxRank(selectedCards))
      console.log(getMaxRank(upCards))
      return compareRank(
        getMaxRank(selectedCards),
        getMaxRank(upCards)
      );
      case 'pair':
      console.log("对子");
      return compareRank(
        getPairCore(selectedCards),
        getPairCore(upCards)
      );
      case 'triple':
      case 'threeWithSingle':
      case 'threeWithPair':
      console.log("三张/三带系列");
      console.log(getTrioCore(selectedCards))
      console.log(getTrioCore(upCards))
      
      return compareRank(
        getTrioCore(selectedCards),
        getTrioCore(upCards)
      );
      case 'straight':
      console.log("顺子");
      // 顺子必须长度相同才能比较
      if (selectedCards.length !== upCards.length) return false;
      return compareRank(
        getStraightMax(selectedCards),
        getStraightMax(upCards)
      );
      
      case 'doubleStraight':
      console.log("连对");
      // 连对必须连续对数相同
      const selectedPairs = getContinuousPairs(selectedCards);
      const upPairs = getContinuousPairs(upCards);
      if (selectedPairs.length !== upPairs.length) return false;
      return compareRank(
        selectedPairs[selectedPairs.length-1], // 取最大对值
        upPairs[upPairs.length-1]
      );
      case 'airplane':
      console.log("飞机");
      return compareRank(
        getAirplaneCore(selectedCards),
        getAirplaneCore(upCards)
      );
      case 'fourWithTwo':
      case 'fourWithTwoPairs':
      console.log("炸弹带两张/两对");
      return compareRank(
        getBombCore(selectedCards),
        getBombCore(upCards)
      );
      case 'bomb':
      console.log("炸弹");

        return compareRank(
          getBombCore(selectedCards),
          getBombCore(upCards)
        );
    }
    console.log("验证到头")
  }

  /******************** 工具函数 ********************/
// 通用比较函数（假设已转换牌值为数字）
export const compareRank = (a, b) => a > b;
// 扑克牌权重转换函数
export function getRankValue(rank) {
  // 先处理特殊牌型（王）
  if (rank === 'joker') return 200;   // 小王
  if (rank === 'Joker') return 300;  // 大王
  
  // 处理普通点数牌
  return pointWeights[rank] || 0;    // 从你的 pointWeights 对象中取值
}

// 卡牌排序比较器
export function compareCard(a, b) {
  return getRankValue(a.rank) - getRankValue(b.rank);
}
// 获取单张/顺子最大值（需先排序）
export function getMaxRank(cards) {
  if (cards.length === 0) return 0; // 处理空数组
  const sorted = [...cards].sort(compareCard); // 创建副本避免修改原数组
  return getRankValue(sorted[sorted.length - 1].rank); // 动态转换最后一张牌的 rank
}
// 获取对子核心牌值
export function getPairCore(cards) {
  const counts = countRanks(cards);
  for (let rank in counts) {
    if (counts[rank] === 2) return getRankValue(rank);
  }
  return 0;
}
// 获取三张核心牌值（用于三带系列）
export function getTrioCore(cards) {
  const counts = countRanks(cards);
  console.log(counts)
  for (let rank in counts) {
    if (counts[rank] === 3) return getRankValue(rank);
  }
  return 0;
}
// 获取顺子最大值（已排序后的最后一张）
export function getStraightMax(cards) {
  if (cards.length < 5) return 0;
  const sorted = [...cards].sort(compareCard);
  return getRankValue(sorted[sorted.length-1].rank);
}
// 获取连续对序列（返回牌值数组）
export function getContinuousPairs(cards) {
  const counts = countRanks(cards);
  const pairs = [];
  for (let rank in counts) {
    if (counts[rank] === 2) pairs.push(getRankValue(rank));
  }
  pairs.sort((a,b) => a - b);
  
  // 检查是否连续（差值均为1）
  for (let i=1; i<pairs.length; i++) {
    if (pairs[i] - pairs[i-1] !== 1) return [];
  }
  return pairs;
}
// 统计牌值出现次数（通用）
export function countRanks(cards) {
  const count = {};
  cards.forEach(card => {
    const rank = card.rank;
    count[rank] = (count[rank] || 0) + 1;
  });
  return count;
}
// 获取连续三张最大值（飞机核心）
export function getAirplaneCore(cards) {
  const trios = [];
  const counts = countRanks(cards);
  
  // 统计所有三张
  for (let rank in counts) {
    if (counts[rank] === 3) {
      trios.push(getRankValue(rank));
    }
  }
  
  // 检查是否连续（如555666）
  trios.sort((a,b) => a - b);
  for (let i=1; i<trios.length; i++) {
    if (trios[i] - trios[i-1] !== 1) return 0;
  }
  return trios.length > 0 ? trios[trios.length-1] : 0;
}

// 获取炸弹核心值（四张牌值）
export function getBombCore(cards) {
  const counts = countRanks(cards);
  for (let rank in counts) {
    if (counts[rank] === 4) return getRankValue(rank);
  }
  return 0;
}
/******************** 工具函数 ********************/